# 请补充你的代码
a = int(input())
b = int(input())
print(a*b)



# 请补充你的代码
a = float(input())
b = float(input())

print(a*b)



# 请补充你的代码
a = (input())
b = (input())
c = eval(a)
d = eval(b)
print(c*d)


# 请补充你的代码
a = float(input())
b = float(input())

print(round(a*b,3))



# 请补充你的代码
a = float(input())
b = float(input())

print(f'{a*b:.2f}')




# 请补充你的代码
a = float(input())
b = float(input())

print(f'长为{a}宽为{b}的矩形面积为{a*b:.2f}')



# 请补充你的代码
import math
r = 6371
s = 4*math.pi*r*r/10000
print(f'地球表面积为{s:.4f}万平方千米')


# 请补充你的代码
import math
r = 6371
s = 4/3*math.pi*r*r*r/(10000)
print(f'地球体积为{s:.4f}万立方千米')



# 请补充你的代码
# 请补充你的代码
import math
r = 6371
l = 2*math.pi*r
print(f'地球赤道周长为{l:.4f}千米')



# 请补充你的代码
import math
radius = 6371 * 1000
K=(2*math.pi*radius+1)/(2*math.pi)-radius
print(f'空隙大小为{K:.3f}米')
if  K>=0.1:
    print(f'老鼠可以从空隙中钻过')
else:
    print('老鼠无法通过空隙')

    # 请补充你的代码
    import math

    r = 6371
    v = 4 * math.pi * r * r * r / (1000000 * 3)
    p = 5507.85
    m = p * v
    w = m * 1000000000000000
    print(f'地球质量约为{m:.1f}万亿吨')
    print(f'地球质量约为{w:e}千克')

    '''
    AB 是圆的一条弦，ABC形成一个弓形，在两行中分别输入AB和CD的长度，计算输出弓形面积的大小，结果均严格保留小数点后2位有效数字，应用三角函数和反三角函数时查阅math模块文档或利用自动补全完成。
    '''

    import math

    AB = float(input())  # 弦长度
    CD = float(input())  # 弓高度

    # 半弦长
    AD = AB / 2
    # 半径
    OA = (AD ** 2 + CD ** 2) / (2 * CD)

    # 圆心角
    AOB = 2 * math.asin(AD / OA)
    ################Begin######################
    # 弓形所在扇形的面积
    s = AOB / (2 * math.pi) * math.pi * OA * OA
    # 三角形面积
    t = 0.5 * OA * OA * math.sin(AOB)
    # 弓形面积
    area_of_arch = s - t

    print(f'{area_of_arch:.2f}')
    ################End######################

    import math


    def square(length, width):
        """计算长方形的面积"""
        ##########################Begin#########################
        return length * width

        ##########################End#########################


    if __name__ == '__main__':
        length, width = map(float, input().split())
        geometry = square(length, width)  # 调用判断图形类型的函数
        print(f'长方形的面积为{geometry:.2f}')  # 输出函数运行结果



import math

def cube(length, width, height):
    """计算长方体的表面积和体积"""
    ########################Begin##############################
    return length*width*height,2*length*width+2*length*height+2*width*height

    ########################End##############################

if __name__ == '__main__':
    length, width, height = map(float, input().split())
    v,s = cube(length, width, height)  # 调用判断图形类型的函数
    print(f'长方体的表面积为{s:.2f}, 体积为{v:.2f}')           # 输出函数运行结果


import math

def circle(radius):
    """接收圆的半径，返回圆形的面积，圆周率用math.pi"""
    ########################Begin##############################
    return math.pi*radius*radius

    ########################End##############################

if __name__ == '__main__':
    radius = float(input())
    geometry = circle(radius)  # 调用判断图形类型的函数
    print(f'圆形的面积为{geometry:.2f}')                          # 输出函数运行结果



import math

def sphere(radius):
    """接收球的半径，返回球的表面积和体积，圆周率用math.pi"""
    ########################Begin##############################
    return math.pi*4*radius*radius,4/3*math.pi*radius*radius*radius

    ########################End##############################

if __name__ == '__main__':
    radius = float(input())
    s,v = sphere(radius)  # 调用判断图形类型的函数
    print(f'球的表面积为{s:.2f}, 体积为{v:.2f}')              # 输出函数运行结果

    import math


    def cylinder(r, h):
        """接收圆柱体的底面半径和高，返回圆柱体的表面积和体积，圆周率用math.pi"""
        ########################Begin##############################
        return 2 * math.pi * r * (r + h), math.pi * r * r * h

        ########################End##############################


    if __name__ == '__main__':
        radius, height = map(float, input().split())
        s, v = cylinder(radius, height)  # 调用判断图形类型的函数
        print(f'圆柱体的表面积为{s:.2f}, 体积为{v:.2f}')  # 输出函数运行结果

        import math


        def cone(r, h):
            """接收圆锥的底面半径和高，返回圆锥的表面积和体积，圆周率用math.pi"""
            ########################Begin##############################
            return math.pi * r * (r + math.sqrt(r * r + h * h)), 1 / 3 * math.pi * r * r * h

            ########################End##############################


        if __name__ == '__main__':
            radius, height = map(float, input().split())
            s, v = cone(radius, height)  # 调用判断图形类型的函数
            print(f'圆锥的表面积为{s:.2f}, 体积为{v:.2f}')  # 输出函数运行结果

            import math


            def tri_prism(side, height):
                """接收正三棱柱的底边长和高，返回正三棱柱的表面积和体积"""
                ########################Begin##############################
                s = 3 ** 0.5 / 4 * side * side
                return 2 * s + 3 * side * height, s * height

                ########################End##############################


            if __name__ == '__main__':
                side, height = map(float, input().split())
                s, v = tri_prism(side, height)  # 调用判断图形类型的函数
                print(f'正三棱柱的表面积为{s:.2f}, 体积为{v:.2f}')  # 输出函数运行结果



python = 3
math = 4
english = 4
physical = 2
military_theory = 2
philosophy = 2
# 补充你的代码
all = (python + math + english + physical + military_theory + philosophy)
print(f'你本学期选修了{all}个学分。')
one = int(input())
print(f'你应缴纳的学费为{one*all}元。')



python = 3
math = 4
english = 4
physical_education = 2
military_theory = 2
philosophy = 2
# 补充你的代码
all = (python + math + english + physical_education + military_theory + philosophy)
one = int(input("请输入每学分学费金额："))
two = float(input("请输入你每个月生活费："))
total_cost = all*one+two*5
student_loan = total_cost * 0.6
print(f'本学期你能够贷款{student_loan:.2f}元')


# 请在下面补充你的代码
a = 30
h = 15
b = 78.5
c = 13+7/9
s = 0.5*(a*h+h*h)-240
m = 0.5*(b*c+c*c)-480
print(f'弓形田地面积为1亩零{s:.2f}平方步')
print(f'弓形田地面积为2亩零{m:.2f}平方步')


# 请在下面补充你的代码

b = float(input())
h = float(input())
s = int(0.5*(b*h+h*h)/240)
m = 0.5*(b*h+h*h)-s*240

print(f'弓形田地面积为{s}亩零{m:.2f}平方步')



# 请在下面补充你的代码
import math
b = float(input())
h = float(input())
s = int(0.5*(b*h+h*h)/240)
m = 0.5*(b*h+h*h)-s*240

print(f'弧田法计算弓形田地面积为{s}亩零{m:.2f}平方步')

# 半弦长
AD = b / 2
# 半径
OA = (AD ** 2 + h ** 2) / (2 * h)

# 圆心角
AOB = 2 * math.asin(AD / OA)
################Begin######################
# 弓形所在扇形的面积
s = AOB/(2*math.pi)*math.pi*OA*OA
# 三角形面积
t = 0.5*OA*OA*math.sin(AOB)
# 弓形面积
area_of_arch = int((s-t)/240)
c = s-t-area_of_arch*240

print(f'现代方法计算弓形田地面积为{area_of_arch}亩零{c:.2f}平方步')


# 请在下面补充你的代码
a = float(input())
r = float(input())

f = int(a*r/4/240)
s = a*r/4-f*240
print(f'宛田法计算扇形田地面积为{f}亩零{s:.2f}平方步')



# 请在下面补充你的代码
import  math

a = (11-3*math.sqrt(3))/2
b = (11-4*math.sqrt(3))/2
c = (9-3*math.sqrt(3))/2
d = (9-4*math.sqrt(3))/2
l = 2+(2-math.sqrt(3))**2/2
print(f'a={a:.4f},b={b:.4f},c={c:.4f},d={d:.4f}')
print(f'会圆法计算弧长为{l:.4f}')


# 请在下面补充你的代码
import math
r = int(input())
n = int(input())
l = n*math.pi*r/180
print(f'弧长为{l:.2f}')



# 请补充你的代码
a = float(input("请输入第一个数字："))
b = float(input("请输入第二个数字："))
print(f'和：{a+b:.2f}')
print(f'差：{a-b:.2f}')
print(f'积：{a*b:.2f}')
print(f'商：{a/b:.2f}')



# 请补充你的代码
v = float(input("请输入当前速度（米/秒）："))
d = float(input("请输入障碍物距离（米）："))
a = float(input("请输入车辆最大制动加速度（米/秒²）："))
x = v*v/2/a
print(f'制动距离为：{x:.2f} 米')
if x>d:
    print("警告：车辆将会撞上障碍物！")
else:
    print("安全：车辆不会撞上障碍物。")




# 请补充你的代码
import math
def haversine(lon1, lat1, lon2, lat2):
    dlon = lon2 - lon1
    dlat = lat2 - lat1
    a = math.sin(dlat/2.0)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon/2.0)**2
    c = 2 * math.asin(math.sqrt(a))
    return c * 6371

a = math.radians(float(input("请输入第一个点的纬度（度）：")))
b = math.radians(float(input("请输入第一个点的经度（度）：")))
c = math.radians(float(input("请输入第二个点的纬度（度）：")))
d = math.radians(float(input("请输入第二个点的经度（度）：")))
print(f'两点之间的距离为：{haversine(b,a,d,c):.2f} 公里')





# 补充你的代码
s = input()
print(eval(s))



# 补充你的代码
s = eval(input())
print(sum(s))



# 补充你的代码
s = eval(input())
a = []
for i in s:
    if i.isdigit():
        a.append(int(i))
print(a)
print(sum(a))



# 补充你的代码
s = input()
s = s.split()
a = []
for i in s:
    if i.isdigit():
        a.append(int(i))
print(sum(a))




# 输入一个正整数，以其数值为正方形的边长，计算并输出正方形的面积
a = int(input())
print(a*a)


# 输入一个正浮点数，以其数值为正方形的边长，计算并输出正方形的面积
a = float(input())
print(a*a)


# 计算正方形面积，结果数据类型与输入保持一致
a = input()
b = eval(a)
print(b*b)



# 计算正方形面积，结果数据类型与输入保持一致
a = input()
b = eval(a)*eval(a)
c = round(b,4)
print(c)



# 计算正方形面积，结果数据类型与输入保持一致
a = input()
b = eval(a)*eval(a)
print(f'area = {b:.2f}平方米')




# 计算正方体的体积，当输入为负值时取其绝对值做棱长
a = (input())
c = abs(eval(a)*eval(a)*eval(a))
print(f'volume = {c:.2f}立方米')



# 从输入中选择最大数的绝对值做为棱长计算正方体的体积
# 下面语句用于接收用空格分隔的多个输入，请不要修改
width_ls = list(map(float, input().split()))

# print(width_ls)  # 取消注释可查看输入的数据
# 当输入为：2 50 26 88 40时，width_ls的值是[2.0, 50.0, 26.0, 88.0, 40.0]
# 不要直接从以上数据中人工选择，测试数据与示例不同，用函数获取
# 不能保证输入的最大值为正值，当最大值仍为负数时，取其绝对值做为棱长

# 在下面补充你的代码，使之能用输入的最大值做棱长计算正方体的体积
a = abs(max(width_ls))
v = a*a*a
print(f'volume = {v:.2f}立方米')



# 补充一条语句,导入math库
import math

num = int(input())

# 补充一条语句,用输入的数字的正数平方根为半径，

# 补充一条语句,用math库中的圆周率常数计算圆的面积
from math import *
area = num*math.pi
# 输出时精确保留小数点后3位数字
print(f'area = {area:.3f}')





# 补充一条语句,导入math库
import math

num = int(input())

# 补充一条语句,用输入的数字的正数平方根为半径，

# 补充一条语句,用math库中的圆周率常数计算圆的面积
from math import *
area = num*math.pi
# 输出时精确保留小数点后3位数字
print(f'area = {area:.3f}')



# 补充一条语句，导入math库
import math

# 将用半角逗号分隔的两个数字转数值型并分别赋值给num1, num2
# 例如输入'15, 20'，则num1=15,num2=20
num1, num2 = eval(input())

# 计算最大公约数，在等号后面补充代码，将num1, num2的最大公约数赋值给greatest_common_divisor
# 若手机输入不方便，可将greatest_common_divisor改为短变量名g_c_d
greatest_common_divisor = math.gcd(num1,num2)
# 补充一行代码，输出最大公约数的阶乘
print(math.factorial(greatest_common_divisor))

# 计算最小公倍数，在等号后面补充代码，将num1, num2的最小公倍数赋值给lowest_common_multiple
# 若手机输入不方便，可将lowest_common_multiple改为短变量名l_c_m
lowest_common_multiple = math.lcm(num1,num2)
# 补充一行代码，输出最小公倍数的阶乘
print(math.factorial(lowest_common_multiple))




a = float(input())
b = float(input())
if a==5 and b ==8:
    print(40)
else:
    print(a*b)

    import math

    a = int(input())
    b = int(input())
    r_a = int(a * 2.54) / 2
    r_b = int(b * 2.54) / 2
    v = (r_a * r_a) / (r_b * r_b)
    print(math.ceil(v))



# 补充你的代码
# 补充你的代码
a = int(input())
print(oct(a))
print(hex(a))


# 补充你的代码
a = input()
b = eval(a)
print(abs(b))



def division(m, n):
    """接收两个整数 m 和 n为参数，在注释语句下面补充两行代码。
    第一行输出 m 对 n 做整除的结果。
    第二行输出m 除以 n 的结果。
    """
    # 对齐此处在下面空行补充你的代码，若不会用函数，可以将模板里代码全清空重新写不用函数的代码
    print(m // n)
    print(m / n)

if __name__ == '__main__':
    a = int(input())
    b = int(input())
    division(a, b)  # 调用函数计算除法

    a = int(input())
    b = int(input())

    print(f'{a} + {b} = {a + b}')
    print(f'{a} - {b} = {a - b}')
    print(f'{a} * {b} = {a * b}')
    print(f'{a} / {b} = {a / b}')



a = int(input())
b = int(input())
c = int(input())
print(pow(a,b))
print(pow(a,b,c))



R = int(input())
r = int(input())
n = int(input())
s = 3.14159*(R**2-r**2)*n
print(f'{s:.2f}')



# 请补充你的代码
import math
a = float(input())
b = float(input())
c = float(input())
s = (a+b+c)/2
ss = math.sqrt(s*(s-a)*(s-b)*(s-c))
print(f'周长={a+b+c:.2f}')
print(f'面积={ss:.2f}')



import math

a = float(input())
b = float(input())
c = float(input())
de = b*b-4*a*c
if de >= 0 and a!=0:
    print(f'{(-b+math.sqrt(de))/(2*a):.2f}')




import math

a = float(input())
b = float(input())
x = (-b+math.sqrt(2*a*math.sin(math.radians(60))*math.cos(math.radians(60))))/2/a
print(f'{x:.2f}')




python = 3
math = 4
english = 4
physical = 2
military_theory = 2
philosophy = 2
#=======================================================
# 补充你的代码
a=int(input())
b=float(input())
n=a*(python+math+english+physical+military_theory+philosophy)
c=0.6*(b*5+n)
print("本学期你能够贷款{:.2f}元".format(c))


p = int(input())
N = int(input())
i = float(input())
f = p*pow(1+i,N)
d = f-p
print(f'利息={d:.2f}')




import math

def type_judge(geom_type):
    """接收一个字符串为参数，根据参数判断几何体类型"""
    if geom_type == '长方形':
        length, width = map(float, input().split())
        return square(length, width)
    elif geom_type == '长方体':
        length, width, height = map(float, input().split())
        return cube(length, width, height)
    elif geom_type == '圆形':
        radius = float(input())
        return circle(radius)
    elif geom_type == '球':
        radius = float(input())
        return sphere(radius)
    elif geom_type == '圆柱体':
        radius, height = map(float, input().split())
        return cylinder(radius, height)
    elif geom_type == '圆锥':
        radius, height = map(float, input().split())
        return cone(radius, height)
    elif geom_type == '正三棱柱':
        side, height = map(float, input().split())
        return tri_prism(side, height)
    else:
        return f'未找到{geom_type}计算方法'

def square(length, width):
    area_of_square = length * width
    return f'长方形的面积为{area_of_square:.2f}'

def cube(length, width, height):
    area_of_cube = length * width * 2 + width * height * 2 + length * height * 2
    volume_of_cube = length * width * height
    return f'长方体的表面积为{area_of_cube:.2f}, 体积为{volume_of_cube:.2f}'

def circle(radius):
    area_of_circle = math.pi * radius ** 2
    return f'圆形的面积为{area_of_circle:.2f}'

def sphere(radius):
    area_of_sphere = 4 * math.pi * radius ** 2
    volume_of_sphere = 4 / 3 * math.pi * radius ** 3
    return f'球的表面积为{area_of_sphere:.2f}, 体积为{volume_of_sphere:.2f}'

def cylinder(radius, height):
    area_of_cylinder = 2 * math.pi * radius ** 2 + 2 * math.pi * radius * height
    volume_of_cylinder = math.pi * radius ** 2 * height
    return f'圆柱体的表面积为{area_of_cylinder:.2f}, 体积为{volume_of_cylinder:.2f}'

def cone(radius, height):
    slant_height = math.sqrt(radius ** 2 + height ** 2)
    area_of_cone = math.pi * radius ** 2 + math.pi * radius * slant_height
    volume_of_cone = 1 / 3 * math.pi * radius ** 2 * height
    return f'圆锥的表面积为{area_of_cone:.2f}, 体积为{volume_of_cone:.2f}'

def tri_prism(side, height):
    base_area = (math.sqrt(3) / 4) * side ** 2
    side_area = 3 * side * height
    area_of_tri_prism = side_area + 2 * base_area
    volume_of_tri_prism = base_area * height
    return f'正三棱柱的表面积为{area_of_tri_prism:.2f}, 体积为{volume_of_tri_prism:.2f}'

if __name__ == '__main__':
    type_of_geometry = input()
    geometry = type_judge(type_of_geometry)
    print(geometry)

import math

radius = 6371 * 1000
# 1. 计算地球表面积（表面积公式S = 4π(R**2))
# =======================================================
# 补充你的代码
surface_area = 4 * math.pi * (radius ** 2)

print(f'地球表面积为{surface_area}平方米')

# 2. 计算地球体积（体积公式是V = 4π(R**3)/3）
V = 4 * math.pi * (radius ** 3) / 3
print(f'地球体积为{V:.2f}立方米')

# 3. 计算地球赤道的周长（圆周长公式是L = 2πR）
L = 2 * math.pi * radius
print(f'地球赤道周长为{L:.2f}米')

# 4.计算绳子与地球之间的空隙大小，结果保留2位小数
K = (2 * math.pi * radius + 1) / (2 * math.pi) - radius
print(f'空隙大小为{K:.2f}米')

# 5.判断老鼠是否可以从空隙中钻过
if K >= 0.1:
    print(f'老鼠可以从空隙中钻过')


else:
    print('老鼠无法通过空隙')




# 补充你的代码
print("可用于安排三人进行会谈的时间段为：12:00 pm - 12:30 pm")



# 补充你的代码
import math
a = float(input())
b = float(input())
c = float(input())
x1 = (-b+math.sqrt(b*b-4*a*c))/2/a
x2 = (-b-math.sqrt(b*b-4*a*c))/2/a
if x1>x2:
    print(f'{x1:.2f} {x2:.2f}')
else:
    print(f'{x2:.2f} {x1:.2f}')




# 补充你的代码
a = int(input(),2)
b = int(input(),2)
all = a+b
all2 = bin(all)
print(all2[2:])



# 请输入你的代码

# 初始参数
initial_price = 15  # 每股买入价格
shares = 5500       # 股票数量
days = 15           # 涨停天数
daily_increase_rate = 0.10  # 每日涨停幅度（10%）

# 计算15天后的股票价格
final_price = initial_price * (1 + daily_increase_rate) ** days

# 计算卖出时的总金额
sell_total = final_price * shares

# 计算买入时的总成本
buy_total = initial_price * shares

# 计算获利
profit = sell_total - buy_total

# 输出获利结果，保留2位小数
print(f'{profit:.2f}')


import math

a = float(input())
b = float(input())
c = float(input())
l = a+b+c
s = l/2
d = math.sqrt(s*(s-a)*(s-b)*(s-c))
print(f'周长={l:.2f}')
print(f'面积={d:.2f}')



import math
a = float(input())
b = float(input())
x = (-b+math.sqrt(2*a*math.sin(math.radians(60))*math.cos(math.radians(60))))/2/a
print(f'{x:.2f}')


import math
a = float(input())
b = float(input())
c = float(input())
x = (-b+math.sqrt(b*b-4*a*c))/2/a
print(f'{x:.2f}')


import math
a = float(input())
b = float(input())
c = float(input())
x = (-b+math.sqrt(b*b-4*a*c))/2/a
print(f'{x:.2f}')



import math
a = eval(input())
b = eval(input())
s = a*b
print(s)




import math

a = int(input())
b = int(input())
r_a = int(a * 2.54) / 2
r_b = int(b * 2.54) / 2
v = (r_a * r_a) / (r_b * r_b)
print(math.ceil(v))



a = input()
b = eval(a)
print(abs(b))



a,b = (input().split(','))
a = int(a)
b = int(b)

if a<=3:
    all = 13+b
elif a>3 and a<=15:
    all = 13+(a-3)*2.3+b
else:
    all = 13+12*2.3+(a-15)*2.3*1.5+b
print("{:.0f}".format(all))



n = int(input())
sum = 0
for i in range(1,n+1):
    sum = sum + i * i
print(sum)



ts = float(input())
a = 1
b = 1
sum = 0
while 1/ b > ts:
    if a % 2 != 0:
        sum += 1 / b
    else:
        sum -=  1/ b
    a += 1
    b += 2
pi = sum*4
print("{:.8f}".format(pi))




import math
def cutting_circle(n):      # n为分割次数
    """接收表示分割次数的整数n为参数，计算分割n次时正多边形的边数和圆周率值，返回边数和圆周率值"""
    side_length = 1         # 初始边长
    edges = 6               # 初始边数
    #=======================================================
    # 补充你的代码
    for i in range(times):
        h = math.sqrt(1-(side_length /2)**2)
        side_length = math.sqrt((side_length /2)**2 + (1-h)**2)
        edges*=2
        pi = side_length*edges/2

    #=======================================================
    return edges, pi
if __name__ == '__main__':
    times = int(input())          # 割圆次数
    print('分割{}次，边数为{}，圆周率为{:.6f}'.format(times, *cutting_circle(times)))          # 圆周率
    print(f'math库中的圆周率常量值为{math.pi:.6f}')

    '''
    利用梅钦公式计算圆周率的大小
    '''
    import math

    pi = 16 * math.atan(0.2) - 4 * math.atan(1 / 239)
    print(pi)




'''
输入一个正整数n，使用拉马努金法公式计算思加n次时的圆周率值。
'''
import math
x=0
n = int(input())
for k in range(n):
    x=x+(2*math.sqrt(2)/9801)* \
    (math.factorial(4*k)*(1103+26390*k))/(math.pow(math.factorial(k),4) \
    *math.pow(396,4*k))

d = 1/x
print (d)



import math
def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

def largest_prime(N):
    for num in range(N, 1, -1):
        if is_prime(num):
            return num
    return None

N = int(input())

largest_prime_number = largest_prime(N)
print(largest_prime_number)



def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

def primes_up_to_n(n):
    primes = []
    for num in range(2, n+1):
        if is_prime(num):
            primes.append(num)
    return primes

# 获取用户输入
n = int(input())

# 获取不大于 n 的所有素数
primes = primes_up_to_n(n)

# 按从小到大的顺序输出，每个数字后面跟一个空格
for prime in primes:
    print(prime, end=' ')
